package com.t3rik.mobile.mes.service.impl

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper
import com.baomidou.mybatisplus.extension.plugins.pagination.Page
import com.t3rik.common.constant.MsgConstants
import com.t3rik.common.enums.mes.OrderStatusEnum
import com.t3rik.common.exception.BusinessException
import com.t3rik.common.utils.DateUtils
import com.t3rik.common.utils.SecurityUtils
import com.t3rik.mes.pro.domain.ProTask
import com.t3rik.mes.pro.service.IProTaskService
import com.t3rik.mobile.mes.dto.TaskClaimRequestDTO
import com.t3rik.mobile.mes.service.ITaskClaimService
import jakarta.annotation.Resource
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional

/**
 * 任务认领服务实现
 * @author t3rik
 * @date 2024/12/18
 */
@Service
class TaskClaimServiceImpl : ITaskClaimService {

    @Resource
    lateinit var proTaskService: IProTaskService

    /**
     * 员工自主认领任务
     */
    @Transactional(rollbackFor = [Exception::class])
    override fun claimTasks(claimRequest: TaskClaimRequestDTO): String {
        // 参数校验
        if (claimRequest.taskIds.isEmpty()) {
            throw BusinessException("任务ID不能为空")
        }

        val currentUserId = SecurityUtils.getUserId()
        val currentUserName = SecurityUtils.getUsername()
        val nowDate = DateUtils.getNowDate()

        // 查询要认领的任务
        val tasks = proTaskService.selectProTaskByTaskIds(claimRequest.taskIds)
        
        if (tasks.isEmpty()) {
            throw BusinessException("未找到指定的任务")
        }

        // 验证任务状态和可认领性
        val invalidTasks = mutableListOf<String>()
        val validTaskIds = mutableListOf<Long>()
        
        for (task in tasks) {
            when {
                // 任务已经分配给其他人
                task.taskUserId != null && task.taskUserId != currentUserId -> {
                    invalidTasks.add("${task.taskCode}(已分配给其他人)")
                }
                // 任务状态不是草稿状态
                task.status != OrderStatusEnum.PREPARE.code -> {
                    invalidTasks.add("${task.taskCode}(状态不允许认领)")
                }
                // 任务已超过完成时间
                task.endTime != null && task.endTime.before(nowDate) -> {
                    invalidTasks.add("${task.taskCode}(已超过完成时间)")
                }
                else -> {
                    validTaskIds.add(task.taskId)
                }
            }
        }

        // 更新可认领的任务
        if (validTaskIds.isNotEmpty()) {
            val updateResult = proTaskService.lambdaUpdate()
                .`in`(ProTask::getTaskId, validTaskIds)
                .set(ProTask::getTaskUserId, currentUserId)
                .set(ProTask::getTaskBy, currentUserName)
                .set(ProTask::getStatus, OrderStatusEnum.CONFIRMED.code)
                .update()
                
            if (!updateResult) {
                throw BusinessException("任务认领失败")
            }
        }

        // 构建返回信息
        val successCount = validTaskIds.size
        val failedCount = invalidTasks.size
        
        return when {
            failedCount == 0 -> "成功认领${successCount}个任务"
            successCount == 0 -> "认领失败：${invalidTasks.joinToString("、")}"
            else -> "成功认领${successCount}个任务，失败${failedCount}个：${invalidTasks.joinToString("、")}"
        }
    }

    /**
     * 员工取消认领任务
     */
    @Transactional(rollbackFor = [Exception::class])
    override fun cancelClaimTasks(claimRequest: TaskClaimRequestDTO): String {
        println("=== 取消认领调试开始 ===")
        println("请求参数 - 任务IDs: ${claimRequest.taskIds}")
        
        // 参数校验
        if (claimRequest.taskIds.isEmpty()) {
            println("参数校验失败：任务ID不能为空")
            throw BusinessException("任务ID不能为空")
        }

        val currentUserId = SecurityUtils.getUserId()
        val nowDate = DateUtils.getNowDate()
        println("当前用户ID: $currentUserId, 当前时间: $nowDate")

        // 查询要取消认领的任务
        val tasks = proTaskService.selectProTaskByTaskIds(claimRequest.taskIds)
        println("查询到的任务数量: ${tasks.size}")
        
        if (tasks.isEmpty()) {
            println("查询结果为空，抛出异常")
            throw BusinessException("未找到指定的任务")
        }

        // 验证任务状态和可取消认领性
        val invalidTasks = mutableListOf<String>()
        val validTaskIds = mutableListOf<Long>()
        
        for (task in tasks) {
            // 记录调试信息
            println("调试信息 - 任务ID: ${task.taskId}, 任务编码: ${task.taskCode}, 当前认领人: ${task.taskUserId}, 任务状态: ${task.status}, 当前用户: $currentUserId")
            
            when {
                // 任务未被认领
                task.taskUserId == null -> {
                    println("验证失败: 任务 ${task.taskCode} 尚未认领")
                    invalidTasks.add("${task.taskCode}(任务尚未认领)")
                }
                // 任务不是当前用户认领的
                task.taskUserId != currentUserId -> {
                    println("验证失败: 任务 ${task.taskCode} 不是当前用户认领的 - 任务认领人: ${task.taskUserId}, 当前用户: $currentUserId")
                    invalidTasks.add("${task.taskCode}(非本人认领的任务)")
                }
                // 任务状态不允许取消认领(只有CONFIRMED状态可以取消)
                task.status != OrderStatusEnum.CONFIRMED.code -> {
                    println("验证失败: 任务 ${task.taskCode} 状态不允许取消认领 - 期望: ${OrderStatusEnum.CONFIRMED.code}, 实际: ${task.status}")
                    invalidTasks.add("${task.taskCode}(状态不允许取消认领,当前状态:${task.status})")
                }
                // 任务已超过完成时间
                task.endTime != null && task.endTime.before(nowDate) -> {
                    println("验证失败: 任务 ${task.taskCode} 已超过完成时间")
                    invalidTasks.add("${task.taskCode}(已超过完成时间)")
                }
                else -> {
                    println("验证通过: 任务 ${task.taskCode} 可以取消认领")
                    validTaskIds.add(task.taskId)
                }
            }
        }

        // 记录验证结果
        println("验证结果 - 有效任务ID: $validTaskIds, 无效任务: $invalidTasks")

        // 更新可取消认领的任务
        if (validTaskIds.isNotEmpty()) {
            println("开始更新任务状态，有效任务ID: $validTaskIds")
            val updateResult = proTaskService.lambdaUpdate()
                .`in`(ProTask::getTaskId, validTaskIds)
                .set(ProTask::getTaskUserId, null)
                .set(ProTask::getTaskBy, null)
                .set(ProTask::getStatus, OrderStatusEnum.PREPARE.code)
                .update()
                
            println("更新结果: $updateResult")
                
            if (!updateResult) {
                println("更新失败，抛出异常")
                throw BusinessException("取消认领失败")
            } else {
                println("更新成功")
            }
        } else {
            println("没有有效任务需要更新")
        }

        // 构建返回信息
        val successCount = validTaskIds.size
        val failedCount = invalidTasks.size
        
        // 如果所有任务都是"任务尚未认领"，可能是前端缓存问题，返回成功信息
        if (failedCount > 0 && invalidTasks.all { it.contains("任务尚未认领") }) {
            println("所有任务都是'任务尚未认领'，返回特殊成功信息")
            return "任务已取消认领，请刷新页面"
        }
        
        val result = when {
            failedCount == 0 -> "成功取消认领${successCount}个任务"
            successCount == 0 -> "取消认领失败：${invalidTasks.joinToString("、")}"
            else -> "成功取消认领${successCount}个任务，失败${failedCount}个：${invalidTasks.joinToString("、")}"
        }
        
        println("返回结果: $result")
        println("=== 取消认领调试结束 ===")
        return result
    }

    /**
     * 查询可认领的任务列表（分页）
     */
    override fun listAvailableTasks(queryWrapper: LambdaQueryWrapper<ProTask>, page: Page<ProTask>) {
        proTaskService.page(page, queryWrapper)
    }

    /**
     * 查询可认领的任务列表（不分页）
     */
    override fun getAvailableTasks(): List<ProTask> {
        return proTaskService.lambdaQuery()
            .eq(ProTask::getStatus, OrderStatusEnum.PREPARE.code)
            .and { wrapper ->
                wrapper.isNull(ProTask::getTaskUserId)
                    .or()
                    .eq(ProTask::getTaskUserId, SecurityUtils.getUserId())
            }
            .orderByDesc(ProTask::getCreateTime)
            .list()
    }
}